// 版权所有2009 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package main

import (
	"bytes"
	"context"
	"flag"
	"fmt"
	"go/ast"
	"go/parser"
	"go/printer"
	"go/scanner"
	"go/token"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"runtime"
	"runtime/pprof"
	"strings"

	"cmd/internal/diff"

	"golang.org/x/sync/semaphore"
)

var (
	// 主要操作模式
	list        = flag.Bool("l", false, "list files whose formatting differs from gofmt's")
	write       = flag.Bool("w", false, "write result to (source) file instead of stdout")
	rewriteRule = flag.String("r", "", "rewrite rule (e.g., 'a[b:len(a)] -> a[b:]')")
	simplifyAST = flag.Bool("s", false, "simplify code")
	doDiff      = flag.Bool("d", false, "display diffs instead of rewriting files")
	allErrors   = flag.Bool("e", false, "report all errors (not just the first 10 on different lines)")

	// 调试
	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to this file")
)

// 与go/format/format保持同步。去
const (
	tabWidth    = 8
	printerMode = printer.UseSpaces | printer.TabIndent | printerNormalizeNumbers

	// PrinterNormalizedNumbers是指在打印时规范化数字文字前缀
	// 和指数。请参阅https:
	// 
	// go/printer中专门为go/format和cmd/gofmt定义了该值。
	printerNormalizeNumbers = 1 << 30
)

// fdSem保护同时打开的文件描述符的数量。
// 
// 目前，根据观察，许多
// 平台默认内核限制为256，这是任意设置为200。理想情况下，也许我们应该从支持该系统调用的平台上的rlimit派生
// 它。
// 
// 不跟踪从该包外部打开的文件描述符，
// 因此该限制可能是近似值。
var fdSem = make(chan bool, 200)

var (
	rewrite    func(*token.FileSet, *ast.File) *ast.File
	parserMode parser.Mode
)

func usage() {
	fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [path ...]\n")
	flag.PrintDefaults()
}

func initParserMode() {
	parserMode = parser.ParseComments
	if *allErrors {
		parserMode |= parser.AllErrors
	}
}

func isGoFile(f fs.DirEntry) bool {
	// 忽略非Go文件
	name := f.Name()
	return !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go") && !f.IsDir()
}

// 序列器执行并行任务，这些任务可能会写入输出，但会以确定的顺序发出该
// 输出。
type sequencer struct {
	maxWeight int64
	sem       *semaphore.Weighted   // 按输入字节加权（内存开销的近似代理）
	prev      <-chan *reporterState // 1缓冲
}

// newSequencer返回一个序列器，该序列器允许并发任务达到最大权重
// 并将任务的输出写入out和err。
func newSequencer(maxWeight int64, out, err io.Writer) *sequencer {
	sem := semaphore.NewWeighted(maxWeight)
	prev := make(chan *reporterState, 1)
	prev <- &reporterState{out: out, err: err}
	return &sequencer{
		maxWeight: maxWeight,
		sem:       sem,
		prev:      prev,
	}
}

// exclusive是一个权重，可以传递给sequencer，使
// 在没有任何其他并发任务的情况下执行任务。
const exclusive = -1

// 添加块，直到sequencer有足够的空闲权重，然后添加f作为
// 要并行执行的任务。
// 
// 如果权重为负或大于sequencer的最大
// 权重，则添加块直到所有其他任务完成，然后任务
// 以独占方式执行（阻止所有其他要添加的调用，直到完成）。
// 
// f可以在一个goroutine中并发运行，但它对传入的
// reporter的输出将相对于sequencer中的其他任务是顺序的。
// 
// 如果f调用报告器上的方法，该方法的执行可能会阻止
// 直到上一个任务完成。（为了最大限度地提高并发性，f应该
// 在完成任何可并行工作之前避免调用报告程序。）
// 
// 如果f返回非零错误，该错误将在f的输出
// （如果有）后报告，并将导致非零的最终退出代码。
func (s *sequencer) Add(weight int64, f func(*reporter) error) {
	if weight < 0 || weight > s.maxWeight {
		weight = s.maxWeight
	}
	if err := s.sem.Acquire(context.TODO(), weight); err != nil {
		// 将任务从“执行f”更改为“报告错误”。
		weight = 0
		f = func(*reporter) error { return err }
	}

	r := &reporter{prev: s.prev}
	next := make(chan *reporterState, 1)
	s.prev = next

	// 并行启动f：它可以一直运行，直到调用r上的一个方法，此时
	// 它将阻塞，直到上一个任务释放输出状态。
	go func() {
		if err := f(r); err != nil {
			r.Report(err)
		}
		next <- r.getState() // 发布下一个任务。
		s.sem.Release(weight)
	}()
}

// AddReport在任何先前添加的
// 任务输出后，向s打印错误，导致最终退出代码为非零。
func (s *sequencer) AddReport(err error) {
	s.Add(0, func(*reporter) error { return err })
}

// GetExitCode等待之前添加的所有任务完成，然后返回适合传递给操作系统的序列的
// 退出代码。出口
func (s *sequencer) GetExitCode() int {
	c := make(chan int, 1)
	s.Add(0, func(r *reporter) error {
		c <- r.ExitCode()
		return nil
	})
	return <-c
}

// 报告者报告输出、警告和错误。
type reporter struct {
	prev  <-chan *reporterState
	state *reporterState
}

// reporterState携带一个reporter实例的状态。
// 
// 一次只能有一名记者访问reporterState。
type reporterState struct {
	out, err io.Writer
	exitCode int
}

// getState阻塞，直到之前的任何报告程序都使用完报告程序
// state，然后返回状态进行操作。
func (r *reporter) getState() *reporterState {
	if r.state == nil {
		r.state = <-r.prev
	}
	return r.state
}

// Warnf向报告者的错误流发出警告消息，而不更改其退出代码。
func (r *reporter) Warnf(format string, args ...any) {
	fmt.Fprintf(r.getState().err, format, args...)
}

// Write向报告程序的输出流发送一个片段。
// 
// 任何错误都会返回给调用者，并且不会影响
// 报告者的退出代码。
func (r *reporter) Write(p []byte) (int, error) {
	return r.getState().out.Write(p)
}

// 报表向报告程序的错误流发出非零错误，
// 将其退出代码更改为非零值。
func (r *reporter) Report(err error) {
	if err == nil {
		panic("Report with nil error")
	}
	st := r.getState()
	scanner.PrintError(st.err, err)
	st.exitCode = 2
}

func (r *reporter) ExitCode() int {
	return r.getState().exitCode
}

// 如果info==nil，我们将格式化stdin而不是文件。
// 如果in==nil，则源是具有给定文件名的文件的内容。
func processFile(filename string, info fs.FileInfo, in io.Reader, r *reporter) error {
	src, err := readFile(filename, info, in)
	if err != nil {
		return err
	}

	fileSet := token.NewFileSet()
	fragmentOk := false
	if info == nil {
		// 如果我们正在格式化stdin，我们接受一个程序片段来代替
		// 完整的源文件。
		fragmentOk = true
	}
	file, sourceAdj, indentAdj, err := parse(fileSet, filename, src, fragmentOk)
	if err != nil {
		return err
	}

	if rewrite != nil {
		if sourceAdj == nil {
			file = rewrite(fileSet, file)
		} else {
			r.Warnf("warning: rewrite ignored for incomplete programs\n")
		}
	}

	ast.SortImports(fileSet, file)

	if *simplifyAST {
		simplify(file)
	}

	res, err := format(fileSet, file, sourceAdj, indentAdj, src, printer.Config{Mode: printerMode, Tabwidth: tabWidth})
	if err != nil {
		return err
	}

	if !bytes.Equal(src, res) {
		// 格式已更改
		if *list {
			fmt.Fprintln(r, filename)
		}
		if *write {
			if info == nil {
				panic("-w should not have been allowed with stdin")
			}
			// 在覆盖原始
			perm := info.Mode().Perm()
			bakname, err := backupFile(filename+".", src, perm)
			if err != nil {
				return err
			}
			fdSem <- true
			err = os.WriteFile(filename, res, perm)
			<-fdSem
			if err != nil {
				os.Rename(bakname, filename)
				return err
			}
			err = os.Remove(bakname)
			if err != nil {
				return err
			}
		}
		if *doDiff {
			data, err := diffWithReplaceTempFile(src, res, filename)
			if err != nil {
				return fmt.Errorf("computing diff: %s", err)
			}
			fmt.Fprintf(r, "diff -u %s %s\n", filepath.ToSlash(filename+".orig"), filepath.ToSlash(filename))
			r.Write(data)
		}
	}

	if !*list && !*write && !*doDiff {
		_, err = r.Write(res)
	}

	return err
}

// readFile读取文件名的内容，由info描述。
// 如果in为非nil，readFile将直接从中读取。
// 否则，readFile打开并读取文件本身，
// 同时打开的文件数量受fdSem限制。
func readFile(filename string, info fs.FileInfo, in io.Reader) ([]byte, error) {
	if in == nil {
		fdSem <- true
		var err error
		f, err := os.Open(filename)
		if err != nil {
			return nil, err
		}
		in = f
		defer func() {
			f.Close()
			<-fdSem
		}()
	}

	// 计算文件大小并以最小的分配读取其内容。
	// 
	// 如果我们有来自filepath的文件信息。WalkDir，使用它使
	// 成为大小合适的缓冲区，避免ReadAll的重新分配。
	// 
	// 如果大小未知（或伪造，或溢出整数），请返回
	// 独立于大小的ReadAll。
	size := -1
	if info != nil && info.Mode().IsRegular() && int64(int(info.Size())) == info.Size() {
		size = int(info.Size())
	}
	if size+1 <= 0 {
		// 我们不知道该文件是常规文件，因此我们没有可靠的大小。
		var err error
		src, err := io.ReadAll(in)
		if err != nil {
			return nil, err
		}
		return src, nil
	}

	// 我们尝试读取大小+1字节，以便检测修改：如果我们
	// 读取的大小超过字节，则文件同时被修改。
	// （如果发生这种情况，我们可以，比如，附加到src以完成读取，或者
	// 继续使用一个截断的缓冲区——但事实上它完全改变了
	// 表明可能有人在编辑文件，所以我们更喜欢
	// 停止以避免损坏它。）
	src := make([]byte, size+1)
	n, err := io.ReadFull(in, src)
	if err != nil && err != io.ErrUnexpectedEOF {
		return nil, err
	}
	if n < size {
		return nil, fmt.Errorf("error: size of %s changed during reading (from %d to %d bytes)", filename, size, n)
	} else if n > size {
		return nil, fmt.Errorf("error: size of %s changed during reading (from %d to >=%d bytes)", filename, size, len(src))
	}
	return src[:n], nil
}

func main() {
	// 任意将正在运行的工作限制为2MB乘以线程数。
	// 
	// 解析树和输出的实际开销将取决于文件的
	// 细节，但这至少使进程的占用空间
	// 大致与GOMAXPROCS成比例。
	maxWeight := (2 << 20) * int64(runtime.GOMAXPROCS(0))
	s := newSequencer(maxWeight, os.Stdout, os.Stderr)

	// 在单独的函数
	// 中调用gofmtMain，这样它就可以使用defer并让它们在退出前运行。
	gofmtMain(s)
	os.Exit(s.GetExitCode())
}

func gofmtMain(s *sequencer) {
	flag.Usage = usage
	flag.Parse()

	if *cpuprofile != "" {
		fdSem <- true
		f, err := os.Create(*cpuprofile)
		if err != nil {
			s.AddReport(fmt.Errorf("creating cpu profile: %s", err))
			return
		}
		defer func() {
			f.Close()
			<-fdSem
		}()
		pprof.StartCPUProfile(f)
		defer pprof.StopCPUProfile()
	}

	initParserMode()
	initRewrite()

	args := flag.Args()
	if len(args) == 0 {
		if *write {
			s.AddReport(fmt.Errorf("error: cannot use -w with standard input"))
			return
		}
		s.Add(0, func(r *reporter) error {
			return processFile("<standard input>", nil, os.Stdin, r)
		})
		return
	}

	for _, arg := range args {
		switch info, err := os.Stat(arg); {
		case err != nil:
			s.AddReport(err)
		case !info.IsDir():
			// 非目录参数总是格式化的。
			arg := arg
			s.Add(fileWeight(arg, info), func(r *reporter) error {
				return processFile(arg, info, nil, r)
			})
		default:
			// 遍历目录，忽略非遍历文件。
			err := filepath.WalkDir(arg, func(path string, f fs.DirEntry, err error) error {
				if err != nil || !isGoFile(f) {
					return err
				}
				info, err := f.Info()
				if err != nil {
					s.AddReport(err)
					return nil
				}
				s.Add(fileWeight(path, info), func(r *reporter) error {
					return processFile(path, info, nil, r)
				})
				return nil
			})
			if err != nil {
				s.AddReport(err)
			}
		}
	}
}

func fileWeight(path string, info fs.FileInfo) int64 {
	if info == nil {
		return exclusive
	}
	if info.Mode().Type() == fs.ModeSymlink {
		var err error
		info, err = os.Stat(path)
		if err != nil {
			return exclusive
		}
	}
	if !info.Mode().IsRegular() {
		// 对于非常规文件，请输入FileInfo。尺寸取决于系统，因此不是
		// 重量的可靠指标。
		return exclusive
	}
	return info.Size()
}

func diffWithReplaceTempFile(b1, b2 []byte, filename string) ([]byte, error) {
	data, err := diff.Diff("gofmt", b1, b2)
	if len(data) > 0 {
		return replaceTempFilename(data, filename)
	}
	return data, err
}

// replaceTempFilename将diff中的临时文件名替换为实际文件名。CDEFG
// /++/tmp/gofmt617882815 2017-02-03 19:13:00.280468375-0500 
// /->
// /--path/to/file。去orig 2017-02-03 19:13:00.280468375-0500 
// /+++path/to/file。go 2017-02-03 19:13:00.280468375-0500 
// /。。。
func replaceTempFilename(diff []byte, filename string) ([]byte, error) {
	bs := bytes.SplitN(diff, []byte{'\n'}, 3)
	if len(bs) < 3 {
		return nil, fmt.Errorf("got unexpected diff for %s", filename)
	}
	// 保留时间戳。
	var t0, t1 []byte
	if i := bytes.LastIndexByte(bs[0], '\t'); i != -1 {
		t0 = bs[0][i:]
	}
	if i := bytes.LastIndexByte(bs[1], '\t'); i != -1 {
		t1 = bs[1][i:]
	}
	// 始终使用斜杠分隔符打印文件路径。
	f := filepath.ToSlash(filename)
	bs[0] = []byte(fmt.Sprintf("--- %s%s", f+".orig", t0))
	bs[1] = []byte(fmt.Sprintf("+++ %s%s", f, t1))
	return bytes.Join(bs, []byte{'\n'}), nil
}

const chmodSupported = runtime.GOOS != "windows"

// 备份文件使用perm权限将数据写入名为filename<number>的新文件，
// 随机选择<number，以确保文件名唯一。backupFile返回
// 所选文件名。
func backupFile(filename string, data []byte, perm fs.FileMode) (string, error) {
	fdSem <- true
	defer func() { <-fdSem }()

	// 创建备份文件
	f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
	if err != nil {
		return "", err
	}
	bakname := f.Name()
	if chmodSupported {
		err = f.Chmod(perm)
		if err != nil {
			f.Close()
			os.Remove(bakname)
			return bakname, err
		}
	}

	// 将数据写入备份文件
	_, err = f.Write(data)
	if err1 := f.Close(); err == nil {
		err = err1
	}

	return bakname, err
}
